package handler

const (
	MAXCANCREATEPLAYERNUM = 1  // 最大可创角数量
	MAXNICKNAMELENGTH     = 16 // 角色名称最大长度
	MAXCREATEROLEDATANUM  = 7  // 最大捏脸数据
)

// func verifyHandler(c *gin.Context) {
// 	//这里处理hand里的信息
// 	//验证是否登录过
// 	// 如果不是成年人，条件不对的时候，就不让上了。
// 	token := c.GetHeader("token")
// 	uid := c.GetHeader("uid")
// 	channel := c.GetHeader("channel")
// 	ts := c.GetHeader("ts")
// 	isadult, err := common.NewString(c.GetHeader("isadult")).ToBool()
// 	if err != nil {
// 		isadult = true
// 	}

// 	//判断是否成年，都防沉谜逻辑
// 	if gcommon.GetCfgInst().Config.IsRealName && !isadult {
// 		//不是成年
// 		n := time.Now()
// 		if n.Hour() != 20 {
// 			c.JSON(http.StatusOK, gin.H{"Result": gcommon.RETMSG_User_Not_Adult})
// 			c.Abort()
// 			return
// 		}

// 	}
// 	if symbol.CheckSig(token, uid, ts, channel, isadult) {
// 		c.Next()
// 	} else {
// 		// c.Next()
// 		c.JSON(http.StatusOK, gin.H{"Result": gcommon.RETMSG_Tips_Param_Fail})
// 		c.Abort()
// 		return
// 	}
// }

// // 专门用于验证是否来自于服务器内部的http请求
// func serverVerifyHandler(c *gin.Context) {
// 	token := c.GetHeader("token")

// 	if server.GetServer().LoginSrvVerifyToken == token {
// 		c.Next()
// 	} else {
// 		c.JSON(400, gin.H{"message": "token invalid"})
// 		c.Abort()
// 		logger.Warn("[serverVerifyHandler] token not match client: ", token)
// 	}
// }

// // 专门用于验证是否来自于服务器内部GM的http请求
// func GmVerifyHandler(c *gin.Context) {
// 	token := c.GetHeader("token")

// 	if server.GetServer().LoginSrvVerifyToken == token {
// 		c.Next()
// 	} else {
// 		logger.Warn("[GmVerifyHandler] token not match client: ", token)
// 		c.JSON(400, gin.H{"message": "GM token invalid"})
// 		c.Abort()
// 	}
// }

// // > 查询玩家创过号的所有服务器
// func alreadyHaveHandler(c *gin.Context) {
// 	var err error
// 	defer func() {
// 		if err != nil {
// 			logger.Warn(err)
// 			if v, ok := err.(*common.Error); ok {
// 				c.JSON(http.StatusOK, gin.H{"Result": v.ErrCode, "ResultMsg": v.String()})
// 			} else {
// 				c.JSON(http.StatusOK, gin.H{"Result": gcommon.RETMSG_Tips_Param_Fail, "ResultMsg": err.Error()})
// 			}
// 		}
// 	}()
// 	msg := &login.GetSrvSingleReq{}
// 	err = c.ShouldBind(msg)
// 	if err != nil {
// 		return
// 	}
// 	logger.Debug(logger.LogKey_LoginFlow, "[handler] alreadyHaveHandler 登录流程 获取已有号的服务器列表 ", msg.Openid, " ", msg.Channel)
// 	uid := common.NewString(c.GetHeader("uid")).ToUint64V()

// 	// uid := logindbmanager.GetInst().QueryCreateUser(msg.Openid, msg.Channel)
// 	pmds := logindbmanager.GetInst().QueryPlayerList(uid)

// 	smds := make(map[uint32]*protoMsg.GroupMD)
// 	smds = logindbmanager.GetInst().QueryGroupListMapByCache() //需要load数据

// 	now := time.Now()
// 	ret := new(login.GetOwnerGroupListAck)
// 	ret.OwnGroupList = make([]login.OwnerGroupInfo, 0, len(smds))
// 	for _, pmd := range pmds {
// 		if groupMd, ok := smds[pmd.GID]; ok {
// 			if groupMd.SrvOpenTime > now.Unix() { //过滤 开服时间在未来 角色 在备服,则不显示
// 				continue
// 			}
// 			ret.OwnGroupList = append(ret.OwnGroupList, login.OwnerGroupInfo{
// 				GroupName: groupMd.GName,
// 				GroupID:   groupMd.GroupID,
// 				GroupLoad: int(groupMd.Load), //负载数据
// 				AreaID:    groupMd.AreaID,
// 				PID:       pmd.PID,
// 				HeroID:    uint64(pmd.JobID),
// 				Level:     pmd.Level,
// 				NickName:  pmd.NickName,
// 				LoginTime: pmd.LoginTime,
// 			})
// 		}
// 	}
// 	c.JSON(http.StatusOK, ret)
// 	return
// }

// // 创建角色
// func createRoleHandler(c *gin.Context) {
// 	var err error
// 	defer func() {
// 		if err != nil {
// 			logger.Warn("Err Message", err)
// 			if v, ok := err.(*common.Error); ok {
// 				c.JSON(http.StatusOK, gin.H{"Result": v.ErrCode})
// 			} else {
// 				c.JSON(http.StatusOK, gin.H{"Result": gcommon.RETMSG_Tips_Param_Fail})
// 			}
// 		}
// 	}()
// 	logger.Debug(logger.LogKey_LoginFlow, "[handler] createRoleHandler 登录流程 创建账号 客户端ip: ", c.ClientIP())

// 	players := make([]login.PlayerLoginData, 0)
// 	msg := &login.UserCreateNPlayerReq{}
// 	err = c.ShouldBindJSON(msg)
// 	if err != nil {
// 		err = gcommon.Err_Tips_Param_Fail.NewErr(err)
// 		return
// 	}
// 	uid := common.NewString(c.GetHeader("uid")).ToUint64V()
// 	// uid := msg.UID

// 	//判断名字长度
// 	strLength := gcommon.Chinese_strlen(msg.NickName)
// 	if strLength > MAXNICKNAMELENGTH {
// 		err = gcommon.Err_User_Name_Length
// 		return
// 	}

// 	//判断正则
// 	isValid := gcommon.IsValidNickName(msg.NickName)
// 	if isValid == false {
// 		err = gcommon.Err_User_Name_Not_Legal
// 		return
// 	}

// 	pmd, err2 := logindbmanager.GetInst().CreatePlayer(uid, msg)
// 	if err2 != nil {
// 		err = err2
// 		return
// 	}

// 	rPlayer := dbservice.NewPlayer(pmd.PID)
// 	err = rPlayer.SavePlayerMD(&dbservice.PlayerMD{
// 		Name:    msg.NickName,
// 		JobID:   int(msg.JobID),
// 		ModelID: 1,
// 	})
// 	if err != nil {
// 		logger.Error(err)
// 	}

// 	createData := login.PlayerLoginData{
// 		PID:      pmd.PID,
// 		NickName: pmd.NickName,
// 		Level:    int32(pmd.Level),
// 		JobID:    int32(pmd.JobID),

// 		LoginTime:  pmd.LoginTime,
// 		CreateTime: uint64(pmd.CreatedAt.Unix()),
// 	}

// 	players = append(players, createData)

// 	ret := login.UserCreateNPlayerAck{
// 		UID:        pmd.UID,
// 		Result:     1,
// 		ResultMsg:  "创建成功",
// 		PlayerData: players,
// 	}
// 	c.JSON(http.StatusOK, ret)
// 	logger.Debug(logger.LogKey_LoginFlow, "[handler] createRoleHandler 登录流程 创建成功 客户端ip: ", c.ClientIP(), " uid: ", ret.UID, " pid: ", createData.PID)
// 	return
// }

// /*
// pickGroupHandler 选择服务器
// 返回group中的所有角色
// */
// func pickGroupHandler(c *gin.Context) {
// 	var err error
// 	defer func() {
// 		if err != nil {
// 			logger.Warn(err)
// 			if v, ok := err.(*common.Error); ok {
// 				c.JSON(http.StatusOK, gin.H{"Result": v.ErrCode, "ResultMsg": v.String()})
// 			} else {
// 				c.JSON(http.StatusOK, gin.H{"Result": gcommon.RETMSG_Tips_Param_Fail, "ResultMsg": err.Error()})
// 			}
// 		}
// 	}()
// 	logger.Debug(logger.LogKey_LoginFlow, "[handler] pickGroupHandler 登录流程 选择服务器 客户端ip: ", c.ClientIP())

// 	var players []login.PlayerLoginData
// 	msg := &login.PickGroupReq{}
// 	err = c.ShouldBindJSON(msg)
// 	if err != nil {
// 		return
// 	}

// 	// 检查是否存在这个玩家信息
// 	uid := common.NewString(c.GetHeader("uid")).ToUint64V()

// 	pmds := logindbmanager.GetInst().QueryGroupPlayer(uid, msg.GroupID)
// 	if pmds != nil {
// 		for _, pmd := range pmds {
// 			playerData := login.PlayerLoginData{
// 				PID:        pmd.PID,
// 				NickName:   pmd.NickName,
// 				JobID:      int32(pmd.JobID),
// 				Level:      int32(pmd.Level),
// 				LoginTime:  pmd.LoginTime,
// 				CreateTime: uint64(pmd.CreatedAt.Unix()),
// 			}

// 			players = append(players, playerData)
// 		}
// 	}
// 	ret := login.PickSrvAck{
// 		UID:        uid,
// 		Result:     1,
// 		ResultMsg:  "",
// 		HB:         gcommon.GetCfgInst().Config.HeartBeat,
// 		PlayerData: players,
// 	}
// 	c.JSON(http.StatusOK, ret)
// 	logger.Debug(logger.LogKey_LoginFlow, "[handler] pickGroupHandler 登录流程 获取服务器 客户端ip: ", c.ClientIP(),
// 		" Openid ", msg.Openid, " uid: ", ret.UID)
// 	return
// }

// /*
// 选择了一个角色进行登录
// 返回这个角色登录对应的gateway地址等信息
// */
// func ChooseHandler(c *gin.Context) {
// 	var err error
// 	defer func() {
// 		if err != nil {
// 			logger.Warn(err)
// 			if v, ok := err.(*common.Error); ok {
// 				c.JSON(http.StatusOK, gin.H{"Result": v.ErrCode, "ResultMsg": v.String()})
// 			} else {
// 				c.JSON(http.StatusOK, gin.H{"Result": gcommon.RETMSG_Tips_Param_Fail, "ResultMsg": err.Error()})
// 			}
// 		}
// 	}()
// 	msg := &login.ChooseHeroReq{}
// 	err = c.ShouldBind(msg)

// 	if err != nil {
// 		return
// 	}
// 	logger.Debug(logger.LogKey_LoginFlow, "[handler] pickGroupHandler 登录流程 登录角色 客户端ip: ", c.ClientIP(), "PID:", msg.PID)

// 	uid := common.NewString(c.GetHeader("uid")).ToUint64V()
// 	userage, _ := common.NewString(c.GetHeader("userage")).ToInt()

// 	pmd := logindbmanager.GetInst().ChosePlayer(msg.PID)
// 	if pmd == nil {
// 		err = gcommon.Err_User_Role_Not_Exist
// 		return
// 	}
// 	userMd := logindbmanager.GetInst().GetUserMdByUid(uid)
// 	if uid != pmd.UID || userMd == nil {
// 		err = gcommon.Err_User_Role_Not_Exist
// 		return
// 	}
// 	group := logindbmanager.GetInst().GetGroupMDByCache(msg.GroupID)
// 	if group == nil || pmd.GID != msg.GroupID {
// 		err = gcommon.Err_Srv_No_Available //服务器不可用
// 		return
// 	}
// 	//非白名单用户 无法进入 服务器维护中的服务器
// 	rdUtil := dbservice.LoginPidUtil(userMd.UserID)
// 	device := rdUtil.GetDeviceInfo()
// 	isWhite := len(logindbmanager.GetInst().GetOneWhiteList(userMd.UserID, userMd.OpenID, userMd.Channel, device.GetDeviceId())) > 0
// 	if !isWhite && group.SrvStatus != protoMsg.SrvStatusEnum_Normal {
// 		err = gcommon.Err_Srv_No_Available //服务器维护中
// 		return
// 	}

// 	rPlayer := dbservice.NewPlayer(pmd.PID)
// 	rPlayer.SavePlayerMD(&dbservice.PlayerMD{
// 		Name:    pmd.NickName,
// 		JobID:   int(pmd.JobID),
// 		ModelID: 1,
// 	})
// 	isadult, aderr := common.NewString(c.GetHeader("isadult")).ToBool()
// 	if aderr != nil {
// 		isadult = true
// 	}
// 	if !gcommon.GetCfgInst().Config.IsRealName {
// 		isadult = true
// 		userage = 30
// 	}
// 	openId := logindbmanager.GetInst().GetOpenIdByUid(pmd.UID)
// 	outaddr, token, err := SetRedisPlayerGateway(uid, msg.PID, msg.GroupID, userage, isadult, openId)
// 	if err != nil {
// 		return
// 	}
// 	//更新登录时间
// 	logindbmanager.GetInst().UpdatePlayerLoginTime(pmd.PID, time.Now())

// 	ret := login.ChossHeroAck{
// 		LobbyAddr: outaddr,
// 		Result:    1,
// 		ResultMsg: "登录成功",
// 		Token:     token,
// 	}
// 	c.JSON(http.StatusOK, ret)
// 	logger.Debug(logger.LogKey_LoginFlow, "[handler] pickGroupHandler 登录流程 登录成功 客户端ip: ", c.ClientIP(), "PID:", msg.PID, ret)
// 	return
// }

// /*
// 删除角色
// */
// func DeleteHandler(c *gin.Context) {
// 	var err error
// 	defer func() {
// 		if err != nil {
// 			logger.Warn(err)
// 			if v, ok := err.(*common.Error); ok {
// 				c.JSON(http.StatusOK, gin.H{"Result": v.ErrCode})
// 			} else {
// 				c.JSON(http.StatusOK, gin.H{"Result": gcommon.RETMSG_Tips_Param_Fail})
// 			}
// 		}
// 	}()
// 	msg := &login.DeleteHeroReq{}
// 	err = c.ShouldBind(msg)

// 	if err != nil {
// 		return
// 	}
// 	pmd := logindbmanager.GetInst().ChosePlayer(msg.PID)
// 	if pmd == nil || pmd.GID != msg.GroupID {
// 		err = gcommon.Err_User_Role_Not_Exist
// 		return
// 	}

// 	pmd.SetDelete()
// 	logindbmanager.GetInst().MysqlDB.Save(pmd)

// 	ret := login.DeleteHeroAck{
// 		Result:    1,
// 		ResultMsg: "删除成功",
// 	}
// 	c.JSON(http.StatusOK, ret)
// 	return
// }

// // 登录后 才可以获得区服列表; 1 白名单可以看到区服列表(备服 和维护中的),2白名单跳过新账号注册角色限制,3 白名单 可以根据设备信息或账号UID/OpenId+ChannelId来设置
// func srvGroupNewHandler(c *gin.Context) {
// 	var err error
// 	defer func() {
// 		if err != nil {
// 			logger.Warn("Err Message", err)
// 			if v, ok := err.(*common.Error); ok {
// 				c.JSON(http.StatusOK, gin.H{"Result": v.ErrCode, "ResultMsg": v.String()})
// 			} else {
// 				c.JSON(http.StatusOK, gin.H{"Result": gcommon.RETMSG_Tips_Param_Fail, "ResultMsg": err.Error()})
// 			}
// 		}
// 	}()

// 	logger.Debug(logger.LogKey_LoginFlow, "[handler] srvGroupNewHandler 客户端ip: ", c.ClientIP())

// 	uid := common.NewString(c.GetHeader("uid")).ToUint64V()
// 	userMd := logindbmanager.GetInst().GetUserMdByUid(uid)
// 	if userMd == nil {
// 		err = gcommon.Err_Tips_Fail.AppendMsg("内部错误 找不到玩家账号数据")
// 		return
// 	}

// 	ret := logindbmanager.GetInst().GetUserGroupListAckByUserInfo(userMd)
// 	// 客户端刷新太频繁,所以屏蔽日志
// 	//logger.Debug(logger.LogKey_LoginFlow, "[handler] srvGroupNewHandler 登录流程 获取服务器列表 客户端ip: ", c.ClientIP())
// 	c.JSON(http.StatusOK, ret)
// }

// // GM获得所有的区服列表; 1 白名单可以看到区服列表,2白名单跳过新账号注册角色限制,3 白名单需要设备信息
// func GmGetGroupListHandler(c *gin.Context) {
// 	ret := logindbmanager.GetInst().GMGetAreaAndGroupListAckByCache()
// 	// 客户端刷新太频繁,所以屏蔽日志
// 	//logger.Debug(logger.LogKey_LoginFlow, "[handler] GmGetGroupListHandler 登录流程 获取服务器列表 客户端ip: ", c.ClientIP())
// 	c.JSON(http.StatusOK, ret)
// }

// /*
// 设置玩家玩这个角色
// 需要把玩家的其他角色T下线
// */
// func SetRedisPlayerGateway(uid, pid uint64, groupid uint32, userage int, isadult bool, openId string) (outaddr, token string, reserr error) {
// 	/*
// 		先把PID有关的Redis数据写完（Session）
// 		然后再替换用户下使用哪个角色的PID（loginPid）
// 	*/
// 	rd := dbservice.GetSessionRedis()
// 	defer rd.Dispose()
// 	psess := dbservice.NewSessionUtil(pid)
// 	reserr = rd.Watch(rd.Ctx, func(tx *redis.Tx) error {
// 		info, err := psess.GetSessInfo(tx)
// 		if errors.Is(err, redis.Nil) {
// 			return nil
// 		} else if err != nil {
// 			return err
// 		}
// 		gateid, _ := common.NewString(info[dbservice.SessionInfo_GatewayId]).ToUint64()
// 		//> 防止crash 后redis里面信息有,但服务器是没了的
// 		/*
// 			Login因为监听了所有Gateway 所以，不能通过这个获取。会找错分配器
// 		*/
// 		smap := serverMgr.GetServerMgr().GetServerMap(serverMgr.GetWatchGateWayPath())
// 		serinfo, err := smap.GetServerByID(groupid, iserver.ServerTypeGateway, gateid)
// 		if err != nil {
// 			serinfo, err = smap.GetBalancing(groupid, iserver.ServerTypeGateway) // serverMgr.GetServerMgr().GetGatewayServerInfoByGroup(groupid)
// 			if err != nil {
// 				return err
// 			}
// 		}
// 		clear(info)
// 		outaddr = serinfo.OuterAddress
// 		info[dbservice.SessionInfo_uidkey] = common.NewStringAny(uid).String()
// 		token, _ = psess.CreateToken()
// 		info[dbservice.SessionInfo_Token] = token
// 		info[dbservice.SessionInfo_GatewayId] = common.NewStringAny(serinfo.ServerID).String()
// 		info[dbservice.SessionInfo_groupid] = common.NewStringAny(serinfo.Group).String()
// 		info[dbservice.SessionInfo_userage] = common.NewStringAny(userage).String()
// 		info[dbservice.SessionInfo_isadult] = common.NewStringAny(isadult).String()
// 		info[dbservice.SessionInfo_OpenIdKey] = openId
// 		_, err = tx.TxPipelined(rd.Ctx, func(p redis.Pipeliner) error {
// 			return psess.SaveSessInfo(p, info)
// 		})
// 		return err
// 	}, psess.Rediskey)
// 	if reserr != nil {
// 		return "", "", reserr
// 	}
// 	// 替换用户下使用哪个角色的PID（loginPid）
// 	loginutil := dbservice.LoginPidUtil(uid)
// 	repid, _ := loginutil.GetSetPID(pid)
// 	if repid != pid && repid != 0 {
// 		//T 老用户下线
// 		KickPlayer(repid)
// 	}
// 	return
// }

// func KickPlayer(pid uint64) {
// 	rd := dbservice.GetSessionRedis()
// 	defer rd.Dispose()
// 	psess := dbservice.NewSessionUtil(pid)
// 	repinfo, err := psess.GetSessInfo(rd)
// 	if errors.Is(err, redis.Nil) {
// 		return
// 	} else if err != nil {
// 		return
// 	}
// 	gateid, _ := common.NewString(repinfo[dbservice.SessionInfo_GatewayId]).ToUint64()
// 	groupid, _ := common.NewString(repinfo[dbservice.SessionInfo_groupid]).ToUint64()
// 	smap := serverMgr.GetServerMgr().GetServerMap(serverMgr.GetWatchGateWayPath())
// 	serinfo, err := smap.GetServerByID(uint32(groupid), iserver.ServerTypeGateway, gateid)
// 	if err != nil {
// 		return
// 	}
// 	HttpTickUser(serinfo.HttpAddress, pid)
// }

// func HttpTickUser(ip string, pid uint64) (result bool, msg string) {
// 	result = true
// 	msg = ""
// 	if ip == "" {
// 		return
// 	}
// 	// if ip == "" {
// 	// 	ip = "10.191.72.37:8091"
// 	// }
// 	url := fmt.Sprintf("http://%s/TickUser", ip)
// 	obj := &login.TickUserReq{PID: pid}
// 	// fmt.Println("URL:>", url)

// 	jsonStr, err := json.Marshal(obj)
// 	if err != nil {
// 		fmt.Println(err)
// 	}

// 	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))
// 	if err != nil {
// 		msg = err.Error()
// 		result = false
// 		return
// 	}
// 	req.Header.Set("Content-Type", "application/json")

// 	client := &http.Client{}
// 	resp, err := client.Do(req)
// 	if err != nil {
// 		msg = err.Error()
// 		result = false
// 		return
// 	}
// 	defer resp.Body.Close()
// 	return
// }

// // 绕过sdk登录，直接进
// func GodChooseHandler(c *gin.Context) {

// 	var err error
// 	defer func() {
// 		if err != nil {
// 			logger.Warn(err)
// 			if v, ok := err.(*common.Error); ok {
// 				c.JSON(http.StatusOK, gin.H{"Result": v.ErrCode, "ResultMsg": v.String()})
// 			} else {
// 				c.JSON(http.StatusOK, gin.H{"Result": gcommon.RETMSG_Tips_Param_Fail, "ResultMsg": err.Error()})
// 			}
// 		}
// 	}()
// 	msg := &login.GodChooseHeroReq{}
// 	err = c.ShouldBind(msg)

// 	if err != nil {
// 		return
// 	}
// 	logger.Debug(logger.LogKey_LoginFlow, "[handler] pickGroupHandler 登录流程 登录角色 客户端ip: ", c.ClientIP(), "PID:", msg.PID)

// 	userage := msg.UserAge

// 	pmd := logindbmanager.GetInst().ChosePlayer(msg.PID)
// 	if pmd == nil {
// 		err = gcommon.Err_User_Role_Not_Exist
// 		return
// 	}
// 	uid := pmd.UID
// 	gid := pmd.GID
// 	rPlayer := dbservice.NewPlayer(pmd.PID)
// 	rPlayer.SavePlayerMD(&dbservice.PlayerMD{
// 		Name:    pmd.NickName,
// 		JobID:   int(pmd.JobID),
// 		ModelID: 1,
// 	})
// 	isadult := msg.IsAdult
// 	if !gcommon.GetCfgInst().Config.IsRealName {
// 		isadult = true
// 		userage = 30
// 	}
// 	openId := logindbmanager.GetInst().GetOpenIdByUid(pmd.UID)
// 	outaddr, token, err := SetRedisPlayerGateway(uid, msg.PID, gid, userage, isadult, openId)
// 	if err != nil {
// 		return
// 	}
// 	//更新登录时间
// 	logindbmanager.GetInst().UpdatePlayerLoginTime(pmd.PID, time.Now())

// 	ret := login.ChossHeroAck{
// 		LobbyAddr: outaddr,
// 		Result:    1,
// 		ResultMsg: "登录成功",
// 		Token:     token,
// 	}
// 	c.JSON(http.StatusOK, ret)
// 	logger.Debug(logger.LogKey_LoginFlow, "[handler] pickGroupHandler 登录流程 登录成功 客户端ip: ", c.ClientIP(), "PID:", msg.PID, ret)
// 	return
// }
